Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume4/tvx/part05

Internet Message Format | 1986-11-30 | 52.6 KB

From: talcott!seismo!gatech!unmvax!wampler (Bruce Wampler)
Subject: tvx 5 of 10
Newsgroups: mod.sources
Approved: [e-mail]

Mod.sources:  Volume 4, Issue 19
Submitted by: gatech!unmvax!wampler (Bruce Wampler)

#--------CUT---------CUT---------CUT---------CUT--------#
#########################################################
#                                                       #
# This is a shell archive file.  To extract files:      #
#                                                       #
#    1)    Make a directory (like tvx) for the files.      #
#    2) Write a file, such as "filen.shar", containing  #
#       this archive file into the directory.           #
#    3) Type "sh file.shar".  Do not use csh.           #
#                                                       #
#########################################################
#
#
echo Extracting tvx_2.c:
sed 's/^X//' >tvx_2.c <<\SHAR_EOF
X/* ========================================================================
X
X    tvx_2.c - Part 2 of main TVX code
X
X============================================================================ */
X
X#include "tvx_defs.ic"        /* note tv_defs will #include stdio.h */
X#include "tvx_glbl.ic"
X
X/* =============================>>> KILLIN <<<============================= */
X  killin(cnt)
X  int cnt;
X  { /* ##  killin - kill cnt lines */
X
X    SLOW int i,lim;
X    SLOW int from,to,ityp,istrt;
X    SLOW int s_curlin, s_curchr, s_echo;
X
X    if (cut_mode)        /* does kill "cut" */
X      {
X    s_echo = echof;
X    echof = FALSE;        /* turn off echo */
X    s_curlin = curlin;    /* save line */
X    save(cnt,FALSE);    /* save those lines */
X    curlin = s_curlin;
X    echof = s_echo;        /* restore things */
X      }
X
X    if (cnt+curlin >= nxtlin || (curlin == nxtlin-1 && cnt >= 0))
X      {             /* special case: deleting rest of buffer */
X    svklin(nxtlin-1);
X    for (i = curlin ; i <= nxtlin-1 ; )
X        kline(*(lines+i++));
X    nxtlin = curlin--;
X    if (curlin > 0)
X      {
X        curchr = *(lines+curlin)+1;
X        newscr();
X      }
X    else
X      {
X        curchr = 0;
X        tvclr();
X      }
X#ifdef SCR_BUF
X    ttflush();
X#endif
X    return;
X      }
X
X    if (cnt < 0)        /* negative kill */
X      {
X    cnt = min(-cnt,curlin-1);    /* all upwards? */
X    dwnlin(-cnt);        /* go up that far */
X      }
X
X    if (cnt != 0)
X      {
X    range(cnt,&to,&from);    /* calculate the line numbers to kill */
X
X    curlin=to;        /* remember new current line */
X
X    svklin(from);    /* save one line */
X    for (i = to ; i <= from ; )        /* mark lines deleted */
X        kline(*(lines+i++));
X
X    lim = min(nxtlin-1,mxline);
X    for (++from ; from <= lim ; )
X      {
X        *(lines+to++) = *(lines+from++);    /* copy next line number */
X      }
X
X    nxtlin=to;
X    if (nxtlin == curlin)
X        --curlin;        /* don't go past end */
X    curchr = *(lines+curlin)+1;    /* remember new current character */
X
X    if (cnt >= 0 && curlin+(tvlins-tvdlin) < nxtlin &&
X      tvdlin < tvlins)    /* killing down */
X      {
X        tvxy(1,tvy);    /* get to start of line */
X        ityp=min(tvlins-tvdlin+1,nxtlin-curlin);
X        if (cnt!=1 || !ckline[0])
X          {
X        tvescr();    /* erase the screen */
X        istrt=curlin;
X          }
X        else
X          {
X        sendcs(ckline);
X        istrt=curlin+ityp-1;
X        tvxy(1,tvlins);
X        ityp=1;
X          }
X        tvtype(istrt,ityp);
X        tvhdln();    /* home to display line */
X      }
X    else if ( cnt != 1)    /* neg and > 1 too complicated */
X        newscr();            /* kill up, just retype whole screen */
X    else if (nxtlin < tvlins)    /* top part of screen */
X      {
X        if (*ckline)        /* kill line defined */
X          {
X        tvxy(1,tvy);        /* get to start of line */
X        sendcs(ckline);        /* just need to kill the line */
X        tvhdln();
X          }
X        else
X        newscr();        /* rewrite it all */
X      }
X    else if (tvdlin < tvlins)    /* must be in last part of buffer */
X      {
X        if (*ckline && *ctopb)    /* kill line & topb defined */
X          {
X        tvxy(1,tvy);        /* get to start of line */
X        sendcs(ckline);        /* kill the line */
X        if (curlin-tvdlin > 0)    /* something to scroll */
X          {
X            tvtopb(1);        /* scroll down one line */
X            tvtype(curlin-tvdlin,1);    /* type the offscreen line */
X            tvdlin++;        /* will start display on next line */
X          }
X        tvhdln();
X          }
X        else
X        newscr();        /* rewrite it all */
X      }
X    else        /* if all else fails */
X        newscr();
X      }
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> KLINE  <<<============================= */
X  kline(ptr)
X  BUFFINDEX ptr;
X  {  /* kline - kill off the line beginning at buff position ptr */
X
X    SLOW BUFFINDEX i;
X
X    for (i=ptr; *(buff+i) != ENDLINE ; )    /* insert GARBAGE to kill */
X    *(buff+i++) = GARBAGE;
X
X    *(buff+i) = GARBAGE;        /* kill the endline */
X  }
X
X/* =============================>>> KPREV  <<<============================= */
X  kprev()
X  { /* kprev - kill from cursor to beginning of line */
X
X    FAST int chrs;
X
X    svklin(curlin);                /* save one line */
X    chrs = curchr - *(lines+curlin) - 1;    /* how much to delete */
X    if (chrs > 0)
X    delnxt(-chrs);    /* won't cause a combine, so don't worry */
X  }
X
X/* =============================>>> KREST  <<<============================= */
X  krest()
X  { /* krest - kill the rest of the line, not including cursor and ENDLINE */
X
X    SLOW int chrs;
X    SLOW BUFFINDEX i;
X
X    svklin(curlin);    /* save one line */
X    chrs=0;
X    for (i=curchr; *(buff+i)!=ENDLINE; ++i)
X    ++chrs;     /* count how much to delete */
X    if (chrs > 0)
X    delnxt(chrs);    /* won't cause combine, so don't worry */
X  }
X
X/* =============================>>> NEATEN <<<============================= */
X  int neaten(count)
X  int count;
X  {  /* neaten - fill lines to current margin */
X
X    SLOW int oldef, i;
X    SLOW BUFFINDEX linbeg;
X    SLOW int retval;
X
X    retval = TRUE;
X    oldef = echof;
X    if (count > 1)
X    echof = FALSE;
X    if (wraplm <= 1 || curlin >= nxtlin-1)
X    goto l900;        /* work only if wrap limit turned on */
X
X    for (i=1 ; i<=count ; ++i)
X      {
X    beglin();        /* start at beginning of line */
X    if (curlin >= nxtlin-1)
X        goto l900;
X
X    /* don't neaten leading space, cr, period or tab */
X
X    if (*(buff+curchr) == '.')
X      {
X        dwnlin(1);
X        continue;        /* skip dot commands */
X      }
X
X    while (*(buff+curchr)== ' ' || *(buff+curchr)==ENDLINE
X      || *(buff+curchr) == 9)
X      {
X        right(1);    /* skip this line */
X      }
X
X    do
X      {
X        if (*(buff+curchr) == ENDLINE)
X          {
X        if (tvx+leftmg < wraplm)    /* combine lines! */
X          {
X            linbeg = *(lines+curlin+1)+1;
X            /* pt to first char of next line */
X            if (*(buff+linbeg) == ' ' || *(buff+linbeg) == ENDLINE
X              || *(buff+linbeg) == 9 || *(buff+linbeg) == '.')
X              {
X            dwnlin(1);
X            break;    /* no more combining */
X              }
X            if (! neat1(1,32))
X            goto l990;
X            goto NEATNEXT;    /* tab over another word */
X          }
X        else
X          {
X            dwnlin(1);    /* no more combining on line */
X            break;
X          }
X          }
X
XNEATNEXT:
X        if (*(buff+curchr-1)==' ' && tvx+leftmg >= wraplm)    /* change to cr */
X          {
X        if (! neat1(-1,CR))    /* delete the blank */
X            goto l990;
X        break;
X          }
X        wordr(1);
X      } /*# end of the repeat */
X    while (1);
X      } /*# end of the for     */
Xl900:
X    echof = oldef;
X    if (oldef && count > 1)
X    newscr();
X#ifdef SCR_BUF
X    else
X    ttflush();
X#endif
X
X    return (retval);
X
Xl990:                /* failure return */
X    retval = FALSE;
X    goto l900;
X  }
X
X/* =============================>>> NEAT1  <<<============================= */
X  neat1(dir, val)
X  int dir, val;
X  {  /* change character dir to val */
X
X    SLOW int oldwrp;
X
X    oldwrp = wraplm;
X    wraplm = 0;
X    if (! delnxt(dir))
X    goto l900;
X    if (! ins_chr(val))
X    goto l900;
X    wraplm = oldwrp;
X    return (TRUE);
Xl900:
X    wraplm = oldwrp;
X    return (FALSE);
X  }
X
X/* =============================>>> NEWSCR <<<============================= */
X  newscr()
X  { /* newscr - retype entire screen, updating cursor position if necessary */
X
X   SLOW int ibeg,cnt;
X
X    if (tvlins != tvhardlines || nxtlin-1 <= tvlins)
X    /* two kinds of screen rewrite */
X    tvclr();            /* clear the screen and home */
X    else
X    tvxy(1,1);
X
X    finddl(&ibeg,&cnt);     /* calculate where it will go */
X    tvtype(ibeg,cnt);        /* type it out */
X    tvhdln();            /* home to display line */
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> OPENLN <<<============================= */
X  openln(cnt)
X  int cnt;
X  {  /* openln - open a new line */
X
X    FAST int i;
X    SLOW int pcnt, oldauto;
X
X    oldauto = autoin; autoin = FALSE;    /* don't allow autoindent */
X    pcnt = cnt >= 0 ? cnt : (-cnt);    /* only allow positive opens */
X    for (i=1; i<=pcnt; ++i)
X    ins_chr(CR);    /* insert right number of newlines */
X    dwnlin(-pcnt);    /* and goto beginning of the opened line */
X    endlin();
X    autoin = oldauto;
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> RANGE  <<<============================= */
X  range(cnt,lbeg,lend)
X  int cnt,*lbeg,*lend;
X  { /* determine a legal line number range given cnt */
X
X    if (cnt <= 0)
X      {
X    *lbeg=max(curlin+cnt,1);
X    *lend=curlin;
X    if (cnt < 0)
X       *lend = (*lend)-1;
X      }
X    else
X      {
X    *lbeg=curlin;
X    *lend=min(nxtlin-1,curlin+cnt-1);
X      }
X }
X
X/* =============================>>> RIGHT  <<<============================= */
X  right(cnt)
X  int cnt;
X  {  /* move cursor right cnt characters
X    newlines count as one character */
X
X    FAST int change,i;
X
X    change=0;            /* nochange yet */
X    if (cnt > 0)
X      {
X    for (i = 1 ; i <= cnt ; ++i)
X      {
X        if (*(buff+curchr)==ENDLINE)
X          {
X        if (curlin+1 >= nxtlin)
X            break;        /* don't go beyond end! */
X        ++curlin;
X        ++change;        /* we've gone down one line */
X        curchr = *(lines+curlin)+1;
X          }
X        else
X        ++curchr;
X      }
X      }
X    else if (cnt < 0)
X      {
X    cnt=(-cnt);
X    for (i = 1 ; i <= cnt ; ++i)
X      {
X        --curchr;
X        if (*(buff+curchr) == BEGLINE)
X          {
X        if (curlin > 1)
X          {
X            --curlin;
X            --change;
X            for (curchr = *(lines+curlin) ; *(buff+curchr)!=ENDLINE ;
X              ++curchr)
X            ;    /* bump curchr to end of the line */
X          }
X        else
X          {
X            ++curchr;
X            break;
X          }
X          }
X      }
X      }
X    if (change != 0)        /* don't do unnecessary change */
X    update(change);
X    tvhdln();
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> SEARCH <<<============================= */
X  search(lexcnt,iarg)
X  int lexcnt,iarg;
X  { /* search - search down in buffer for a pattern */
X
X    SLOW char chr,c0,c1,c2;
X    static int slines;
X    SLOW int oldx,oldy,oldlin;
X    SLOW int change, searchv, lininc, newln, fold_wild;
X    SLOW int l,lbeg,is;
X    SLOW BUFFINDEX ib, bbeg, oldpos, nbbeg;
X    FAST int i;
X
X    SLOW int how_match, set_len;    /* how wild card matching happens */
X    char *cp, *s_getset();
X    SLOW int w_len,inset,extra_len;        /* length of match */
X
X    static int lastsb = 0;
X
X    lininc = (lexcnt >= 0 ) ? 1 : (-1);
X    searchv = FALSE;
X    newln = FALSE;        /* haven't rubbed out 2nd line */
X
X    oldpos = curchr;        /* need to remember for -f */
X    oldx = tvx ; oldy = tvy ; oldlin = curlin;
X
X    ins_mode = TRUE;        /* so ttymode can echo right */
X
X    if (! iarg)
X    goto l100;        /* get arg form search buffer */
X
X    tvmsg("Find?",FALSE);
X
X    if (! grptch(&chr))
X    goto l9000;
X
X    slines=1;            /* only one line so far */
X    for (i = 0; chr != ESC && i < 100; ++i)    /* read in the pattern */
X      {
X    if (chr == delkey && rptcnt[rptuse] <= 0) /* edit interactive input */
X      {
X        --i;        /* adjust i for for loop ++i */
X        if (i >= 0)        /* wipe out chars on screen */
X          {
X        if (sbuff[i] == 0)    /* newline */
X          {
X             --slines; ctrlch(CR); newln = TRUE;
X          }
X        else
X          {
X            if (newln)
X              {
X            tvcout('\\');
X            ctrlch(sbuff[i]);
X              }
X            else
X              {
X            tvcout(BACKSPACE);
X            tvcout(' ');
X            tvcout(BACKSPACE);
X            if (sbuff[i] < ' ' && sbuff[i] != 27)
X              {
X                tvcout(BACKSPACE);
X                tvcout(' ');
X                tvcout(BACKSPACE);
X              }
X              }
X          }
X        --i;        /* wipe the character */
X          }
X#ifdef SCR_BUF
X        ttflush();
X#endif
X        gkbd(&chr);        /* get new char */
X        continue;
X      }
X    sbuff[i]=chr;        /* stuff it away */
X    if (chr == LF)
X      {
X#ifdef USELF
X        tvcout(chr);    /*$$$ to ignore lfs in cr/lf systems */
X#endif
X      }
X    else if (chr == CR)
X      {
X        if (rptcnt[rptuse] <= 0)
X        ctrlch(chr);
X        ++slines;
X        sbuff[i]=0;    /* end of a line */
X      }
X    else
X        ctrlch(chr);    /* echo character, handline control chars */
X
X#ifdef SCR_BUF
X        ttflush();
X#endif
X/*# fetch the next character */
X    if (! grptch(&chr))
X        goto l9000;
X      }
X
X    tvcout('$');    /* echo the escape */
X    tvxy(oldx,oldy);    /* return to old location */
X
X    if (i>0)            /* we got a new pattern */
X      {
X    lastsb=i-1;        /* last valid character */
X    sbuff[i] = 0;        /* make sure an EOS */
X      }
X    fixend();
X
Xl100:
X    extra_len = 0;
X    if (lininc < 0)
X    endlin();
X    bbeg = curchr;        /* start from current character first time */
X    c0 = sbuff[0];        /* initial char of pattern */
X    if (!xcases)            /* get initial character of pattern */
X    c0 = (c0 >= 'A' && c0 <= 'Z') ? c0+' ' : c0;
X
X    for (l = curlin ; l < nxtlin && l ; l += lininc)  /* l is same as l != 0 */
X      {
X    if ( !c0 )        /* !c0 same as c0 == 0 */
X      {
X        if (lastsb == 0)    /* matching cr only? */
X          {
X        dwnlin(1);    /* go down one line */
X        newscr();    /* screen needs updating */
X        goto l8000;
X          }
X        else
X          {
X        for (ib = bbeg; *(buff+ib); ++ib)
X            ;
X        goto l1000;
X          }
X      }
X
Xl900:
X    if (c0 < ' ')    /* save time, check if might be w.c. once */
X      {
X        ib = bbeg;
X        if (*(buff+ib))
X        goto l1000;
X      }
X
X    for (ib=bbeg; *(buff+ib); ++ib)    /* search current line */
X      {
X        c2 = *(buff+ib);    /* next char of buffer */
X        if (!xcases)
X        c2 = (c2 >= 'A' && c2 <= 'Z') ? c2+' ' : c2;
X
X        if (c2 != c0)
X        continue;        /* first characters don't match */
X        else if (lastsb == 0)
X          {         /* one character pattern */
X        curchr = ib+1;
X        curlin = l;
X        goto l5000;    /* successful match */
X          }
X        else
X          {
X        if ((c1 = sbuff[1]) < ' ')    /* possible wild? */
X            goto l1000;
X        c2 = *(buff+ib+1);
X        if (! xcases)    /* fold to lower case */
X          {
X            c1 = (c1 >= 'A' && c1 <= 'Z') ? c1+' ' : c1;
X            c2 = (c2 >= 'A' && c2 <= 'Z') ? c2+' ' : c2; /* clower */
X          }
X        if ( c1 != c2 )
X            continue;    /* first two don't match */
X        else
X            goto l1000;    /* first two match, so possibility */
X          }
X      }
X
X/*    # fall thru => no match on this line */
Xl950:
X    bbeg = *(lines+l+lininc)+1;    /* next beginning character */
X    continue;            /* go check next line */
X
Xl1000:                /* we have two characters matching! */
X    nbbeg = ib;        /* beginning of possible match in buff */
X    lbeg = l;         /* current line we are searching */
X    how_match = 1;        /* assume exact match */
X    for (is = -1 ; ++is <= lastsb ; )
X      {
X        if ((c1 = sbuff[is]) < ' ')        /* possible wild card */
X          {
X        if (c1 == W_span)
X          {
X            extra_len--;
X            how_match = 2;        /* span match */
X            continue;            /* keep scanning search pat */
X          }
X        else if (c1 == W_skip)        /* skip? */
X          {
X            extra_len--;
X            how_match = 0;        /* skip match */
X            continue;            /* keep scanning search pat */
X          }
X        else if ((cp = s_getset(c1,&set_len,&fold_wild)) == NULL)    /* not wild */
X            goto NOT_WILD;        /* continue normally */
X
X    /* ok, to here, then have possible wild card match */
X
X        w_len = 0;
X
X        for ( ; ; )
X          {
X            chr = *(buff + nbbeg);    /* pick up char */
X            if (fold_wild)        /* fold if not user */
X            chr = clower(chr);
X            if (chr == ENDLINE)        /* break on end of line */
X            break;            /* get out */
X
X            inset = s_inset(chr,cp,set_len);    /* see if in set */
X            if ((how_match > 0 && inset) || (how_match == 0 && !inset))
X              {
X            nbbeg++;         /* bump to next char */
X            ++w_len;
X            if (how_match == 1)
X                    break;        /* only once on mode 1 */
X              }
X            else
X            break;
X          }
X
X        if (w_len <= 0)
X          {
X            ++bbeg;     /* this part of line doesn't match */
X            extra_len = 0;
X            if (c0 == 0)
X            goto l950;
X            else
X            goto l900;    /* try rest of current line */
X          }
X
X    /* to here, then exit from wild card match */
X        extra_len += w_len - 1;
X        how_match = 1;            /* back to 1 again */
X        continue;        /* leave cursor on 1st unmatched */
X          }
X
XNOT_WILD:
X        c2 = *(buff+nbbeg);
X        if (! xcases)    /* fold to lower case */
X          {
X        c1 = (c1 >= 'A' && c1 <= 'Z') ? c1+' ' : c1;
X        c2 = (c2 >= 'A' && c2 <= 'Z') ? c2+' ' : c2; /* clower */
X          }
X
X        if ( c1 != c2 )
X          {
X        extra_len = 0;
X        ++bbeg;     /* this part of line doesn't match */
X        if (c0 == 0)
X            goto l950;
X        else
X            goto l900;    /* try rest of current line */
X          }
X
X    /* regular matched sequence */
X
X        if (*(buff+nbbeg)==0 && lbeg+1 < nxtlin)
X          {
X        ++lbeg;
X        nbbeg = *(lines+lbeg)+1;    /* point to next character */
X          }
X        else
X        ++nbbeg;
X      }
X
X/*#  fall through => found the pattern */
X    curlin = lbeg;
X    curchr = nbbeg;
X
Xl5000:
X    change = curlin-oldlin;    /* compute real line change */
X    if ((slines > 1 && iarg) || tvdlin == tvlins || newln)
X        newscr();
X    else
X        update(change);
X    goto l8000;
X      }
X    curchr = oldpos;        /* reset things */
X    tvxy(oldx, oldy);
X    if (slines > 1 && iarg)
X    newscr();        /* patch up screen */
X    pat_buff[0] = 0;
X    tverrb("Not found ");    /* announce failure a little */
X    goto l9000;
X
Xl8000:                /* success return */
X    oldlen = lastsb+1+extra_len;        /* remember the length */
X    save_pat();        /* save the find pattern */
X    savlen = (-1);            /* haven't saved lines */
X    searchv = TRUE;
X
Xl9000:
X    ins_mode = FALSE;
X#ifdef SCR_BUF
X    ttflush();
X#endif
X    return (searchv);
X  }
X
X/* =============================>>> S_GETSET <<<============================= */
X  char *s_getset(wildchr,set_len,fold)
X  char wildchr;        /* wild card character */
X  int *set_len, *fold;        /* length of set, fold flag */
X  {
X    static char sets[] =        /* possible sets */
X      {
X    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
X    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
X    'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
X    '4', '5', '6', '7', '8', '9', '.', ',', '?', '!',
X    '[', ']', '{', '}', '(', ')', '<', '>', '\'','"',
X    '+', '-', '/', '*', '=', '@', '#', '$', '%', '^',
X    '&', '_', '~', '`', '|', '\\', ' ', 9, ';', ':', 0
X      };
X
X    struct wild_set
X      {
X    char wch;
X    int s_start, s_len;
X      };
X
X    static struct wild_set wild_cards[] =
X      {
X    { W_letter,  0, 26 },    /* ^L is a letter, starts at 0, 26 long */
X    { W_digit, 26, 10 },    /* ^D is digit, starts at 26, 10 long */
X    { W_alpha,  0, 36 },    /* ^A is alpha numeric, start at 0, 36 long */
X    { W_punc, 36,  4 },    /* ^P is punctuation, at 36, 4 long */
X    { W_anything,  0, 70 },    /* ^X is any thing, whole set */
X    { W_others, 36, 34 },    /* ^O is non-alphanum, start at 36, 32 long */
X    { 0 ,  0,  0 }    /* end of set */
X      };
X
X    SLOW int i;
X
X    *fold = FALSE;        /* assume won't fold */
X    if (!use_wild)
X    return NULL;        /* not there if not using! */
X
X    for (i = 0 ; wild_cards[i].wch ; ++i)    /* scan list */
X      {
X    if (wildchr == wild_cards[i].wch)    /* found the one we want */
X      {
X        *set_len = wild_cards[i].s_len;
X        *fold = TRUE;
X        return (&sets[ wild_cards[i].s_start ]);
X      }
X      }
X    if (wildchr == W_user)
X      {
X    *set_len = strlen(user_set);
X    return user_set;
X      }
X    else
X    return NULL;
X
X  }
X
X/* =============================>>> S_inset <<<============================= */
X  s_inset(c2,cp,set_len)
X  char c2, *cp;
X  int set_len;
X  {
X    FAST int i;
X
X    for (i = 0 ; i < set_len ; ++i)
X    if (c2 == *(cp+i))
X        return TRUE;
X    return FALSE;
X  }
X
X/* =============================>>> SETPAR <<<============================= */
X  setpar(val,chr)
X  int val;
X  char chr;
X  { /* setpar - reset varoius parameters
X        syntax for setpar is [val]:<let>, where [val] is the new value
X        of the parameter, : is the setpar command, and <let> is the
X        letter of the parameter to set. */
X
X    chr = clower(chr);
X
X    switch (chr)
X      {
X       case 'a':        /* set auto indent */
X         autoin = val > 0;
X        break;
X
X    case 'c':        /* cut mode */
X         cut_mode = val > 0;
X        break;
X
X       case 'e':        /* expand tabs */
X         tabspc = max(val,0);
X        verify(1);        /* need to redisplay */
X        break;
X
X    case 'd':        /* display line */
X        if (val < 1 || val > tvlins)
X        tverrb("Bad par val");
X        else
X          {
X        dsplin=val;
X        verify(1);
X          }
X        break;
X
X       case 'f':        /* set find mode */
X        xcases = val <= 0;
X        break;
X
X    case 'm':        /* match wild cards */
X        use_wild = val;
X        break;
X
X    case 'o':
X        if (rdonly)
X          {
X        tverrb("Can't :o, R/O");
X        break;
X          }
X        tvclr();
X        ask("New output file name: ",dest_file,FNAMESIZE);
X        if (*dest_file)
X        rdonly = FALSE;
X        verify(1);
X        break;
X
X    case 's':        /* scroll lines */
X        if (val < 0 || val > dsplin-1)
X        tverrb("Bad par val");
X        else
X        scroll=val;
X        break;
X
X    case 't':        /* tty mode */
X        tvclr();
X        ttymode = val;
X        ttynext = 1000;
X        verify(1);
X        break;
X
X    case 'r':        /* change repeat buffer in use */
X        if (val < 1 || val > REPEATBUFS)
X        tverrb("Bad par val");
X        else
X        rptuse=val-1;    /* adjust for 0 index int */
X        break;
X
X    case 'u':
X        tvclr();
X        ask("Enter user wild card set: ",user_set,39);
X        verify(1);
X        break;
X
X    case 'v':        /* virtual window size */
X        if (val < 3 || val > tvhardlines)
X        tverrb("Bad par val");
X        else
X          {
X        tvlins = val;            /* set to new display line */
X        ddline = (tvlins / 2) + 1;    /* fix home line */
X        setdscrl();            /* set scroll value */
X        dsplin = ddline;        /* reset these */
X        scroll = dscrl;
X        verify(1);            /* update the screen */
X          }
X        break;
X
X    case 'w':        /* change wrap width */
X        wraplm=val;
X        break;
X
X    default:
X        tverrb("Bad par name");
X      }
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> SNEXT  <<<============================= */
X  snext(lexcnt,iarg)
X  int lexcnt,iarg;
X  { /* snext - find a text pattern across page boundaries */
X
X    SLOW int ihow,pagout;
X
X    if (lexcnt < 0)
X      {
X    tverrb("Search fails");
X    return (FALSE);
X      }
X
X    ihow=iarg;            /* make a local copy */
X    pagout=FALSE;
X    for(;;)
X      {
X    if (! search(lexcnt,ihow))
X      {
X        wtpage(1);        /* write out current page */
X        ihow=FALSE;        /* don't reread search pattern */
X        pagout=TRUE;
X        if (! rdpage())
X          {
X        tvclr();    /* no more text */
X        tverrb("Search fails");
X        return (FALSE);
X          }
X      }
X    else            /* found it */
X      {
X        if (pagout)
X        newscr();
X#ifdef SCR_BUF
X        else
X        ttflush();
X#endif
X        return (TRUE);
X      }
X      }
X  }
X
X/* =============================>>> STORE_RPT <<<============================= */
X  store_rpt(dummy)
X  int dummy;
X  {    /* start at current cursor position, insert into repeat buffer
X       identified until find >$$ or exceed size limit, deleting as it goes */
X
X    SLOW char chr;
X    SLOW int saved, i, val;
X
X    beglin();        /* start by moving to beginning of current line */
X
X    if ((chr = *(buff+curchr)) != '#')    /* get current char, which must be # */
X      {
X    tverrb("Not a valid rpt buff");
X    return (FALSE);
X      }
X    val = *(buff+curchr+1)-'0';        /* pick up buffer number */
X
X    if (!chk_rpt_nr(val))
X    return FALSE;
X
X    delnxt(4);                /* delete the #n:< */
X
X    --val;        /* change to relative */
X
X    saved = 0;                /* no previous chars */
X    for (i = 0 ;  ; ++i)
X      {
X    chr = *(buff+curchr);        /* get the character */
X
X    if (chr == ESC && i > 1 && rptbuf[val][i-1] == ESC &&
X        rptbuf[val][i-2] == loop_end)
X      {
X        rptbuf[val][i-2] = 0;    /* set to 0 */
X        nxtrpt[val] = 0;
X        delnxt(2);            /* delete the 27 and following CR */
X#ifdef SCR_BUF
X        ttflush();
X#endif
X        return TRUE;
X      }
X    if (++saved > 99)
X      {
X        tverrb("Only 100 chars in rpt");
X        return FALSE;
X      }
X    if (chr == ENDLINE)
X        chr = CR;
X    rptbuf[val][i] = chr;            /* save the char */
X    delnxt(1);            /* and delete it */
X      }
X  }
X
X/* =============================>>> SVKLIN <<<============================= */
X  svklin(lin)
X  int lin;
X  { /* svklin - save one line that will be killed */
X
X    SLOW BUFFINDEX from,to;
X
X    to=0;
X    for (from= *(lines+lin)+1; *(buff+from)!=ENDLINE; ++from)
X      {
X    unkbuf[to]= *(buff+from);    /* put it in unkill buffer */
X    to = min(130,to+1);
X      }
X    unkbuf[to]=0;
X  }
X
X/* =============================>>> TOPPAG <<<============================= */
X  toppag()
X  { /* toppag - move cursor to top of the page */
X
X    curlin=1;
X    curchr = *(lines+1)+1;        /* first char of buffer */
X    newscr();
X  }
X
X/* =============================>>> TVIDEFS <<<============================= */
X  tvidefs()
X  { /* initialize these AFTER opening, defaults set by -c */
X
X    dsplin=ddline;
X    scroll=dscrl;
X    xcases=dxcase;
X  }
X
X/* =============================>>> TVINIT <<<============================= */
X  tvinit()
X  { /* perform initializations needed for tv edit */
X
X    FAST BUFFINDEX i;
X    FAST char *chrp;
X    SLOW char *lim;
X    char *malloc();
X
X#ifdef MSDOS
X    BUFFINDEX coreleft();        /* !!! cii-86 dependent */
X#endif
X
X/*    This is a time eater if a big buffer -- if your loader inits
X    mem to some known value, it might be possible to change GARBAGE
X    to that value (be sure no other conflicts, like EOS == 0)     */
X
X/* try for maximum size buffer */
X
X#ifndef GEMDOS
X    if ((lines = (BUFFINDEX *) malloc((MAXLINE+1)*sizeof(BUFFINDEX)))
X       == NULL)        /* line pointer array */
X    exit(1);
X#else
Xif ((lines=(BUFFINDEX *)malloc((unsigned int)((MAXLINE+1)*sizeof(BUFFINDEX))) )
X       == NULL)        /* line pointer array */
X    exit(1);
X#endif
X
X#ifdef UNIX
X    for (mxbuff=MAXBUFF ; (buff = malloc(mxbuff+2))==NULL ; mxbuff -= 1000)
X    ;            /* text buffer pointer */
X#endif
X#ifdef OSCPM
X    for (mxbuff=MAXBUFF ; (buff = malloc(mxbuff+2))==NULL ; mxbuff -= 1000)
X    ;            /* text buffer pointer */
X#endif
X#ifdef GEMDOS
X    for (mxbuff = 60000L ; (buff = malloc((unsigned int) (mxbuff+2)))==NULL
X      ; mxbuff -= 1000L)
X    ;            /* text buffer pointer */
X#endif
X#ifdef MSDOS            /* *** Cii-86 C compiler dependent! */
X
X    /* cii-86 requires you to manually leave some memory left over
X       for the I/O routines to use.  'coreleft' does this. Sigh. */
X
X    if ((mxbuff = (coreleft() - 5000) ) > MAXBUFF)
X    mxbuff = MAXBUFF;
X    for ( ; (buff = malloc(mxbuff+2))==NULL ; mxbuff -= 1000)
X    ;            /* text buffer pointer */
X#endif
X
X    mxline = MAXLINE;
X
X    lim = buff + mxbuff;
X    for (chrp = buff ; chrp <= lim ; *chrp++ = GARBAGE )
X    ;    /* mark as all garbage */
X
X    curlin =            /* init some stuff */
X    oldlen =
X    curchr = 0;
X
X    xoutcm = leftmg = nxtlin = nxtchr = tvdlin = 1;
X    *(buff+mxbuff) = ENDLINE;    /* needs to be ENDLINE for save buffer */
X    nxtsav=mxbuff;        /* point to end of the buffer */
X
X    pat_buff[0] = 0;        /* null pattern buffer */
X
X
X    savlin = savlen = (-1);
X    for (i = 0 ; i < REPEATBUFS ; ++i)
X      {              /* fix repeat buffers to initial state */
X    rptbuf[i][0] = rptcnt[i]= nxtrpt[i] = rptbuf[i][1] = 0;
X      }
X    rptuse=0;            /* start with first repeat buff */
X    bakflg = FALSE;
X    ineof =
X    echof = TRUE;
X  }
X
X/* =============================>>> TVERR  <<<============================= */
X  tverr(str)
X  char str[];
X  { /* tverr -    display an error message on the last line of the screen
X               always writes on screen, returns to old position */
X
X    SLOW int oldx,oldy,oldxot,oldech;
X
X    waserr = TRUE;
X    oldx=tvx ; oldy=tvy ; oldxot=xoutcm ; oldech=echof;
X
X    ttynext = 1000;        /* force new read */
X
X    echof = TRUE;            /* always echo! */
X    tvmsg(str,TRUE);         /* print the message part */
X    tvxy(oldx,oldy);
X    xoutcm=oldxot;
X    echof=oldech;        /* restore to what it was */
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> TVERRB <<<============================= */
X  tverrb(str)
X  char str[];
X  { /* tverrb - display an error message on the last line of the screen
X              always writes on screen, returns to old position */
X
X    sendcs(cerrbg);
X    tverr(str);
X    sendcs(cerred);
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> TVHDLN <<<============================= */
X  tvhdln()
X  { /* tvhdln - home to display line */
X
X    SLOW int xf;
X    xf = findx();
X    tvxy(xf,tvdlin);
X  }
X
X/* =============================>>> TVMSG  <<<============================= */
X  tvmsg(str,intty)
X  char str[];
X  int intty;
X  { /* tvmsg - display a message on the last line of the screen */
X
X    FAST int i;
X    SLOW int oldtty;
X
X    tvxy(1,tvhardlines);
X    tvelin();
X
X    oldtty = ttymode;
X    if (ttymode && intty)
X      {
X    ttymode = FALSE;
X    prompt(">");
X      }
X
X    for (i=0; str[i]; ctrlch(str[i++]))
X    ;
X
X    if (oldtty)        /* end with < if was ttymode */
X    remark("<");
X
X    ttymode = oldtty;
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> TVTYLN <<<============================= */
X  tvtyln(chrptr)
X  BUFFINDEX chrptr;
X  { /* tvtyln - type a line on the screen without cr/lf */
X
X#ifdef ULBD
X    FAST BUFFINDEX i;
X
X    if (cundlb[0] || cboldb[0])    /* check for underline/bold */
X      {
X    for (i = *(lines+curlin)+1 ; *(buff+i)!=ENDLINE ; ++i)
X        if (*(buff+i)==TOGUNDERLINE || *(buff+i)==TOGBOLD)
X          {
X        tvxy(1,tvy);
X        xoutcm=1;
X        tvplin(*(lines+curlin)+1);
X        return;
X          }
X      }
X#endif
X    xoutcm=tvx;
X    tvplin(chrptr);
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> UNKILL <<<============================= */
X  int unkill()
X  { /* unkill the single last line killed */
X
X    SLOW char chrval;
X    FAST int i;
X
X    openln(1);        /* put the CR 1st - makes update pretty */
X    for (i=0; unkbuf[i]; ++i)
X      {
X    chrval = unkbuf[i];
X    if (! ins_chr(chrval))    /* unkill slowly by using insert */
X      {
X        return (FALSE);
X      }
X      }
X    dwnlin(1);        /* back to where we were */
X    return (TRUE);
X  }
X
X/* =============================>>> UPDATE <<<============================= */
X  update(change)
X  int change;
X  { /* update - update the screen when line position has changed
X        will not be used if any alterations have been made */
X
X    SLOW int abschg,bscrol;
X
X    if (! echof)
X    return;
X    abschg =  change;
X
X    bscrol = (ctopb[0]==0) ? 0 : scroll;
X
X    if (change < 0)            /* have to scroll screen down */
X      {
X    abschg = (-change);
X    if (tvdlin-abschg < 1)
X        newscr();
X    else if (curlin < tvdlin)    /* won't fit exactly */
X      {
X        if (tvdlin >= dsplin-scroll && abschg!=1)
X          {
X        tvclr();        /* clear the screen */
X        tvtype(1,tvlins);    /* type out a screen */
X          }
X        tvdlin=curlin;
X      }
X    else if (tvdlin-abschg >= dsplin-scroll)
X        tvdlin -= abschg;
X    else
X      {
X        if (tvdlin > dsplin-scroll)
X          {             /* moving up from below display line */
X        abschg=dsplin-scroll-(tvdlin-abschg);
X        tvdlin=dsplin-scroll;    /* update */
X          }
X        if (ctopb[0]==0)        /* can't do reverse linefeeds */
X        newscr();        /* no choice, redraw screen */
X        else
X          {
X        tvtopb(abschg);        /* make blank lines at top */
X        tvtype(curlin-tvdlin+1,abschg);    /* fill in */
X          }
X      }
X      }
X    else if (change > 0)        /* have to scroll screen up */
X    if ((tvdlin+change>tvlins && tvdlin<dsplin+bscrol) || change>=tvlins)
X        newscr();
X    else if (tvdlin < dsplin+bscrol || nxtlin-1 <= tvlins)
X        if (tvdlin+change > dsplin+bscrol && nxtlin-1 > tvlins)
X        newscr();
X        else
X        tvdlin += change;
X    else if (nxtlin-curlin<=tvlins-tvdlin)    /* on bottom part */
X      {
X        if (tvdlin<=dsplin+bscrol && abschg!=1)
X          {
X        tvclr();        /* rewrite whole screen */
X        tvtype(nxtlin-tvlins,tvlins);
X          }
X        tvdlin=min(tvlins,nxtlin-1)-(nxtlin-curlin)+1;
X      }
X    else
X      {
X        tvbotb(abschg);        /* make room */
X        tvxy(1,tvlins-abschg+1);    /* home to right line */
X        tvtype(curlin+tvlins-tvdlin-abschg+1,abschg);  /* fix up screen */
X        if (tvdlin < dsplin+bscrol)
X        tvdlin=dsplin;
X      }
X    tvhdln();
X#ifdef SCR_BUF
X    ttflush();
X#endif
X  }
X
X/* =============================>>> WORDR  <<<============================= */
X  wordr(cnt)
X  int cnt;
X  {  /* wordr - move cursor over words */
X
X    SLOW int lim,words,incr,lenmov;
X
X    lenmov=0;
X    if (cnt<0)
X      {
X    incr = (-1);        /* change */
X    lim = (-cnt);
X      }
X    else if (cnt == 0)
X      {
X    incr = -1;
X    lim = 0;
X      }
X    else
X      {
X    incr = 1;
X    lim = cnt;
X      }
X
X    for (words=1; words<=lim; ++words)
X      {
X    if ((*(buff+curchr)==ENDLINE && incr>0) ||
X        (*(buff+curchr-1)==BEGLINE && incr<0) )
X      {
X        if (curlin+incr==nxtlin || curlin+incr<1)
X        break;        /* at a buffer limit, so quit */
X        dwnlin(incr);    /* move up or down */
X        lenmov += incr;
X        if (cnt<0)
X        endlin();
X        continue;        /* move to next word */
X      }
X
X/* ok, first, skip over word characters */
X    while (wrdchr(*(buff+curchr)))
X      {
X        if (*(buff+curchr-1)==BEGLINE && incr<=0)
X        goto l100;
X        else
X          {
X        curchr += incr;
X        lenmov += incr;
X          }
X      }
X
X/* now skip over remaining non word chars */
X    while (! wrdchr(*(buff+curchr)))
X       {
X        if ((*(buff+curchr)==ENDLINE && incr>0) || (*(buff+curchr-1)==BEGLINE &&
X          incr<0))
X        break;
X        else
X          {
X        curchr += incr;
X        lenmov += incr;
X          }
X      }
Xl100: ;
X      }
X
X    if (incr < 0)        /* move cursor to beginning of word */
X    while (wrdchr(*(buff+curchr-1)))
X      {
X        curchr += incr;
X        lenmov += incr;
X      }
X    tvhdln();
X#ifdef SCR_BUF
X    ttflush();
X#endif
X    oldlen = lenmov ; savlen=(-1) ;
X  }
X
X/* =============================>>> WRDCHR <<<============================= */
X  int wrdchr(chr)
X  char chr;
X  { /* wrdchr - determine if a character is a "word" type character */
X
X    if ((chr>='a' && chr <= 'z') || (chr >= 'A' && chr <= 'Z') ||
X      (chr >= '0' && chr <= '9'))
X    return (TRUE);
X    else
X     return (FALSE);
X  }
SHAR_EOF
echo Extracting tvx_term.ic:
sed 's/^X//' >tvx_term.ic <<\SHAR_EOF
X/* -----------------  Various terminal definitions ---------------------- */
X/* ********************************************************************** */
X#ifdef IBMPC
X    EXTERN int addx = 31;        /* amount to add to get x */
X    EXTERN int addy = 31;        /* to get y */
X    EXTERN char cxychr = 0;        /* true if convert xy bin to ascii */
X    EXTERN char cversn[12] = "IBM-PC";     /* a version to identify config */
X    EXTERN char cxy1st = 'l';            /* l if line first, c if column 1st */
X    EXTERN char cxybeg[8] = {18,0,0,0,0,0,0,0};    /* start xy control seq  */
X    EXTERN char cxymid[8] = {0,0,0,0,0,0,0,0};  /* middle xy control seq */
X    EXTERN char cxyend[8] = {0,0,0,0,0,0,0,0};  /* end sequence */
X    EXTERN char cerrbg[8] = {16,0,0,0,0,0,0,0}; /* string to print when errors start */
X    EXTERN char cerred[8] = {14,0,0,0,0,0,0,0};  /* when errors done */
X    EXTERN char ctopb[8] = {3,0,0,0,0,0,0,0}; /* top blanks = reverse linefeed */
X    EXTERN char cinit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* start up sequence */
X    EXTERN char cendit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* to end session */
X    EXTERN char cbotb[8] = {10,0,0,0,0,0,0,0};  /* bottom blank line sequence */
X    EXTERN char celin[8] = {1,0,0,0,0,0,0,0};        /* erase to end of line */
X    EXTERN char cescr[8] = {2,0,0,0,0,0,0,0};        /* erase to end of screen */
X    EXTERN char cclears[8]={0,0,0,0,0,0,0,0};    /* clear screen, home cusor */
X    EXTERN char cdelchr[8]={0,0,0,0,0,0,0,0};    /* delete char on screen */
X    EXTERN char ccsrcm[8] = {20,0,0,0,0,0,0,0};    /* set cursor to command mode */
X    EXTERN char ccsrin[8] = {19,0,0,0,0,0,0,0};    /* set cursor to insert mode */
X    EXTERN char ciline[8] = {3,0,0,0,0,0,0,0};        /* insert a line */
X    EXTERN char ckline[8] = {6,0,0,0,0,0,0,0};        /* kill a line */
X    EXTERN char cundlb[8] = {4,0,0,0,0,0,0,0};    /* turn on underline */
X    EXTERN char cundle[8] = {5,0,0,0,0,0,0,0};    /* turn off underline */
X    EXTERN char cboldb[8] = {11,0,0,0,0,0,0,0};    /* start bold */
X    EXTERN char cbolde[8] = {12,0,0,0,0,0,0,0};    /* end bold */
X
X    EXTERN int dsp_mem = 0;
X    EXTERN int ddline = 16;
X    EXTERN int dscrl = 0;
X    EXTERN int dxcase = 0;
X#ifdef USECTRLZ
X    EXTERN int usecz = 1;
X#else
X    EXTERN int usecz = 0;
X#endif
X    EXTERN int autoin = 0;    /* TRUE if auto indent, FALSE otherwise */
X    EXTERN int logdef = 0;    /* backup log file by default 0->no, 1-> yes */
X    EXTERN char delkey = 8;
X    EXTERN int tvlins = 25;    /* number of lines on screen */
X    EXTERN int tvcols = 80;    /* number of columns on screen */
X    EXTERN int tvhardlines = 25;    /* real number of lines */
X    EXTERN int tvx = 0;        /* current x cursor position */
X    EXTERN int tvy = 0;        /* current y cursor position */
X    EXTERN int tvdlin = 0;     /* the "active" display line */
X    EXTERN int dsplin = 0;     /* the default display line */
X    EXTERN int tabspc = 8;     /* spacing for tabs */
X    EXTERN int leftmg = 0;    /* left margin of display */
X    EXTERN int wraplm = 0;    /* auto wrap? */
X    EXTERN int isibmpc = 1;    /* for possible use with a general version */
X
X#endif
X/* ********************************************************************** */
X#ifdef TERMCAP
X    EXTERN int addx = 0;        /* amount to add to get x */
X    EXTERN int addy = 0;            /* to get y */
X    EXTERN char cxychr = 0;        /* true if convert xy bin to ascii */
X    EXTERN char cversn[12] = ":";     /* a version to identify config */
X    EXTERN char cxy1st = 0;            /* l if line first, c if column 1st */
X    EXTERN char cxybeg[8] = {0,0,0,0,0,0,0,0};    /* start xy control seq  */
X    EXTERN char cxymid[8] = {0,0,0,0,0,0,0,0};  /* middle xy control seq */
X    EXTERN char cxyend[8] = {0,0,0,0,0,0,0,0};  /* end sequence */
X    EXTERN char cerrbg[8] = {0,0,0,0,0,0,0,0}; /* string to print when errors start */
X    EXTERN char cerred[8] = {0,0,0,0,0,0,0,0};  /* when errors done */
X    EXTERN char ctopb[8] = {0,0,0,0,0,0,0,0}; /* top blanks = reverse linefeed */
X    EXTERN char cinit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* start up sequence */
X    EXTERN char cendit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* to end session */
X    EXTERN char cbotb[8] = {10,0,0,0,0,0,0,0};  /* bottom blank line sequence */
X    EXTERN char celin[8] = {0,0,0,0,0,0,0,0};        /* erase to end of line */
X    EXTERN char cescr[8] = {0,0,0,0,0,0,0,0};        /* erase to end of screen */
X    EXTERN char cclears[8]={0,0,0,0,0,0,0,0};    /* clear screen, home cusor */
X    EXTERN char cdelchr[8]={0,0,0,0,0,0,0,0};    /* delete char on screen */
X    EXTERN char ccsrcm[8] = {0,0,0,0,0,0,0,0};    /* set cursor to command mode */
X    EXTERN char ccsrin[8] = {0,0,0,0,0,0,0,0};    /* set cursor to insert mode */
X    EXTERN char ciline[8] = {0,0,0,0,0,0,0,0};        /* insert a line */
X    EXTERN char ckline[8] = {0,0,0,0,0,0,0,0};        /* kill a line */
X    EXTERN char cundlb[8] = {0,0,0,0,0,0,0,0};    /* turn on underline */
X    EXTERN char cundle[8] = {0,0,0,0,0,0,0,0};    /* turn off underline */
X    EXTERN char cboldb[8] = {0,0,0,0,0,0,0,0};    /* start bold */
X    EXTERN char cbolde[8] = {0,0,0,0,0,0,0,0};    /* end bold */
X
X    EXTERN int dsp_mem = 0;
X    EXTERN int ddline = 12;    /* unix really needs scroll window */
X    EXTERN int dscrl = 6;
X    EXTERN int dxcase = 0;
X#ifdef USECTRLZ
X    EXTERN int usecz = 1;
X#else
X    EXTERN int usecz = 0;
X#endif
X    EXTERN int autoin = 0;    /* TRUE if auto indent, FALSE otherwise */
X    EXTERN int logdef = 0;    /* backup log file by default 0->no, 1-> yes */
X    EXTERN char delkey = 8;
X    EXTERN int tvlins = 0;    /* number of lines on screen */
X    EXTERN int tvcols = 0;    /* number of columns on screen */
X    EXTERN int tvhardlines = 0;    /* real number of lines */
X    EXTERN int tvx = 0;        /* current x cursor position */
X    EXTERN int tvy = 0;        /* current y cursor position */
X    EXTERN int tvdlin = 0;     /* the "active" display line */
X    EXTERN int dsplin = 0;     /* the default display line */
X    EXTERN int tabspc = 8;     /* spacing for tabs */
X    EXTERN int leftmg = 0;    /* left margin of display */
X    EXTERN int wraplm = 0;    /* auto wrap? */
X    EXTERN int isibmpc = 0;    /* for possible use with a general version */
X
X#endif
X/* ********************************************************************** */
X#ifdef VT100
X    EXTERN int addx = 0;        /* amount to add to get x */
X    EXTERN int addy = 0;            /* to get y */
X    EXTERN char cxychr = 1;        /* true if convert xy bin to ascii */
X    EXTERN char cversn[12] = "VT-100";     /* a version to identify config */
X    EXTERN char cxy1st = 'l';            /* l if line first, c if column 1st */
X    EXTERN char cxybeg[8] = {27,'[',0,0,0,0,0,0};    /* start xy control seq  */
X    EXTERN char cxymid[8] = {';',0,0,0,0,0,0,0};  /* middle xy control seq */
X    EXTERN char cxyend[8] = {'H',0,0,0,0,0,0,0};  /* end sequence */
X    EXTERN char cerrbg[8] = {7,0,0,0,0,0,0,0}; /* string to print when errors start */
X    EXTERN char cerred[8] = {0,0,0,0,0,0,0,0};  /* when errors done */
X    EXTERN char ctopb[8] = {27,'M',0,0,0,0,0,0}; /* top blanks = reverse linefeed */
X    EXTERN char cinit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* start up sequence */
X    EXTERN char cendit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* to end session */
X    EXTERN char cbotb[8] = {10,0,0,0,0,0,0,0};  /* bottom blank line sequence */
X    EXTERN char celin[8] = {27,'[','K',0,0,0,0,0}; /* erase to end of line */
X    EXTERN char cescr[8] = {27,'[','J',0,0,0,0,0};        /* erase to end of screen */
X    EXTERN char cclears[8]={0,0,0,0,0,0,0,0};    /* clear screen, home cusor */
X    EXTERN char cdelchr[8]={0,0,0,0,0,0,0,0};    /* delete char on screen */
X    EXTERN char ccsrcm[8] = {0,0,0,0,0,0,0,0};    /* set cursor to command mode */
X    EXTERN char ccsrin[8] = {0,0,0,0,0,0,0,0};    /* set cursor to insert mode */
X    EXTERN char ciline[8] = {0,0,0,0,0,0,0,0};        /* insert a line */
X    EXTERN char ckline[8] = {0,0,0,0,0,0,0,0};        /* kill a line */
X    EXTERN char cundlb[8] = {0,0,0,0,0,0,0,0};    /* turn on underline */
X    EXTERN char cundle[8] = {0,0,0,0,0,0,0,0};    /* turn off underline */
X    EXTERN char cboldb[8] = {0,0,0,0,0,0,0,0};    /* start bold */
X    EXTERN char cbolde[8] = {0,0,0,0,0,0,0,0};    /* end bold */
X
X    EXTERN int dsp_mem = 0;
X    EXTERN int ddline = 16;
X    EXTERN int dscrl = 0;
X    EXTERN int dxcase = 0;
X#ifdef USECTRLZ
X    EXTERN int usecz = 1;
X#else
X    EXTERN int usecz = 0;
X#endif
X    EXTERN int autoin = 0;    /* TRUE if auto indent, FALSE otherwise */
X    EXTERN int logdef = 0;    /* backup log file by default 0->no, 1-> yes */
X    EXTERN char delkey = 8;
X    EXTERN int tvlins = 24;    /* number of lines on screen */
X    EXTERN int tvcols = 80;    /* number of columns on screen */
X    EXTERN int tvhardlines = 24;    /* real number of lines */
X    EXTERN int tvx = 0;        /* current x cursor position */
X    EXTERN int tvy = 0;        /* current y cursor position */
X    EXTERN int tvdlin = 0;     /* the "active" display line */
X    EXTERN int dsplin = 0;     /* the default display line */
X    EXTERN int tabspc = 8;     /* spacing for tabs */
X    EXTERN int leftmg = 0;    /* left margin of display */
X    EXTERN int wraplm = 0;    /* auto wrap? */
X    EXTERN int isibmpc = 0;    /* for possible use with a general version */
X#endif
X/* ********************************************************************** */
X#ifdef ATARI520                /* like a 25 line VT-52! */
X    EXTERN int addx = 31;        /* amount to add to get x */
X    EXTERN int addy = 31;            /* to get y */
X    EXTERN char cxychr = 0;        /* true if convert xy bin to ascii */
X    EXTERN char cversn[12] = "520ST";     /* a version to identify config */
X    EXTERN char cxy1st = 'l';            /* l if line first, c if column 1st */
X    EXTERN char cxybeg[8] = {27,'Y',0,0,0,0,0,0};    /* start xy control seq  */
X    EXTERN char cxymid[8] = {0,0,0,0,0,0,0,0};  /* middle xy control seq */
X    EXTERN char cxyend[8] = {0,0,0,0,0,0,0,0};  /* end sequence */
X    EXTERN char cerrbg[8] = {27,'p',0,0,0,0,0,0}; /* string to print when errors start */
X    EXTERN char cerred[8] = {27,'q',0,0,0,0,0,0};  /* when errors done */
X    EXTERN char ctopb[8] = {27,'I',0,0,0,0,0,0}; /* top blanks = reverse linefeed */
X    EXTERN char cinit[20] = {27,'w',27,'e',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* start up sequence */
X    EXTERN char cendit[20] = {27,'v',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* to end session */
X    EXTERN char cbotb[8] = {10,0,0,0,0,0,0,0};  /* bottom blank line sequence */
X    EXTERN char celin[8] = {27,'K',0,0,0,0,0,0};        /* erase to end of line */
X    EXTERN char cescr[8] = {27,'J',0,0,0,0,0,0};        /* erase to end of screen */
X    EXTERN char cclears[8]={27,'E',0,0,0,0,0,0};    /* clear screen, home cusor */
X    EXTERN char cdelchr[8]={27,'M',0,0,0,0,0,0};    /* delete char on screen */
X    EXTERN char ccsrcm[8] = {0,'y','4',0,0,0,0,0};    /* set cursor to command mode */
X    EXTERN char ccsrin[8] = {0,'x','4',0,0,0,0,0};    /* set cursor to insert mode */
X    EXTERN char ciline[8] = {27,'L',0,0,0,0,0,0};        /* insert a line */
X    EXTERN char ckline[8] = {27,'M',0,0,0,0,0,0};        /* kill a line */
X    EXTERN char cundlb[8] = {27,'p',0,0,0,0,0,0};    /* turn on underline */
X    EXTERN char cundle[8] = {27,'q',0,0,0,0,0,0};    /* turn off underline */
X    EXTERN char cboldb[8] = {27,'p',0,0,0,0,0,0};    /* start bold */
X    EXTERN char cbolde[8] = {27,'q',0,0,0,0,0,0};    /* end bold */
X
X    EXTERN int dsp_mem = 0;
X    EXTERN int ddline = 16;
X    EXTERN int dscrl = 0;
X    EXTERN int dxcase = 0;
X#ifdef USECTRLZ
X    EXTERN int usecz = 1;
X#else
X    EXTERN int usecz = 0;
X#endif
X    EXTERN int autoin = 0;    /* TRUE if auto indent, FALSE otherwise */
X    EXTERN int logdef = 0;    /* backup log file by default 0->no, 1-> yes */
X    EXTERN char delkey = 8;
X    EXTERN int tvlins = 25;    /* number of lines on screen */
X    EXTERN int tvcols = 80;    /* number of columns on screen */
X    EXTERN int tvhardlines = 25;    /* real number of lines */
X    EXTERN int tvx = 0;        /* current x cursor position */
X    EXTERN int tvy = 0;        /* current y cursor position */
X    EXTERN int tvdlin = 0;     /* the "active" display line */
X    EXTERN int dsplin = 0;     /* the default display line */
X    EXTERN int tabspc = 8;     /* spacing for tabs */
X    EXTERN int leftmg = 0;    /* left margin of display */
X    EXTERN int wraplm = 0;    /* auto wrap? */
X    EXTERN int isibmpc = 0;    /* for possible use with a general version */
X#endif
X/* ********************************************************************** */
X/* ********************************************************************** */
X#ifdef H19
X    EXTERN int addx = 31;        /* amount to add to get x */
X    EXTERN int addy = 31;            /* to get y */
X    EXTERN char cxychr = 0;        /* true if convert xy bin to ascii */
X    EXTERN char cversn[12] = "H19";     /* a version to identify config */
X    EXTERN char cxy1st = 'l';            /* l if line first, c if column 1st */
X    EXTERN char cxybeg[8] = {27,'Y',0,0,0,0,0,0};    /* start xy control seq  */
X    EXTERN char cxymid[8] = {0,0,0,0,0,0,0,0};  /* middle xy control seq */
X    EXTERN char cxyend[8] = {0,0,0,0,0,0,0,0};  /* end sequence */
X    EXTERN char cerrbg[8] = {27,'p',0,0,0,0,0,0}; /* string to print when errors start */
X    EXTERN char cerred[8] = {27,'q',0,0,0,0,0,0};  /* when errors done */
X    EXTERN char ctopb[8] = {27,'I',0,0,0,0,0,0}; /* top blanks = reverse linefeed */
X    EXTERN char cinit[20] = {27,'w',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* start up sequence */
X    EXTERN char cendit[20] = {27,'v',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* to end session */
X    EXTERN char cbotb[8] = {10,0,0,0,0,0,0,0};  /* bottom blank line sequence */
X    EXTERN char celin[8] = {27,'K',0,0,0,0,0,0};        /* erase to end of line */
X    EXTERN char cescr[8] = {27,'J',0,0,0,0,0,0};        /* erase to end of screen */
X    EXTERN char cclears[8]={27,'E',0,0,0,0,0,0};    /* clear screen, home cusor */
X    EXTERN char cdelchr[8]={27,'M',0,0,0,0,0,0};    /* delete char on screen */
X    EXTERN char ccsrcm[8] = {27,'y','4',0,0,0,0,0};    /* set cursor to command mode */
X    EXTERN char ccsrin[8] = {27,'x','4',0,0,0,0,0};    /* set cursor to insert mode */
X    EXTERN char ciline[8] = {27,'L',0,0,0,0,0,0};        /* insert a line */
X    EXTERN char ckline[8] = {27,'M',0,0,0,0,0,0};        /* kill a line */
X    EXTERN char cundlb[8] = {27,'p',0,0,0,0,0,0};    /* turn on underline */
X    EXTERN char cundle[8] = {27,'q',0,0,0,0,0,0};    /* turn off underline */
X    EXTERN char cboldb[8] = {27,'p',0,0,0,0,0,0};    /* start bold */
X    EXTERN char cbolde[8] = {27,'q',0,0,0,0,0,0};    /* end bold */
X
X    EXTERN int dsp_mem = 0;
X    EXTERN int ddline = 16;
X    EXTERN int dscrl = 0;
X    EXTERN int dxcase = 0;
X#ifdef USECTRLZ
X    EXTERN int usecz = 1;
X#else
X    EXTERN int usecz = 0;
X#endif
X    EXTERN int autoin = 0;    /* TRUE if auto indent, FALSE otherwise */
X    EXTERN int logdef = 0;    /* backup log file by default 0->no, 1-> yes */
X    EXTERN char delkey = 8;
X    EXTERN int tvlins = 24;    /* number of lines on screen */
X    EXTERN int tvcols = 80;    /* number of columns on screen */
X    EXTERN int tvhardlines = 24;    /* real number of lines */
X    EXTERN int tvx = 0;        /* current x cursor position */
X    EXTERN int tvy = 0;        /* current y cursor position */
X    EXTERN int tvdlin = 0;     /* the "active" display line */
X    EXTERN int dsplin = 0;     /* the default display line */
X    EXTERN int tabspc = 8;     /* spacing for tabs */
X    EXTERN int leftmg = 0;    /* left margin of display */
X    EXTERN int wraplm = 0;    /* auto wrap? */
X    EXTERN int isibmpc = 0;    /* for possible use with a general version */
X#endif
X/* ********************************************************************** */
X#ifdef HP2621
X    EXTERN int addx = -1;        /* amount to add to get x */
X    EXTERN int addy = -1;            /* to get y */
X    EXTERN char cxychr = 1;        /* true if convert xy bin to ascii */
X    EXTERN char cversn[12] = "HP2621x";     /* a version to identify config */
X    EXTERN char cxy1st = 'l';            /* l if line first, c if column 1st */
X    EXTERN char cxybeg[8] = {27,'&','a',0,0,0,0,0};    /* start xy control seq  */
X    EXTERN char cxymid[8] = {'y',0,0,0,0,0,0,0};  /* middle xy control seq */
X    EXTERN char cxyend[8] = {'C',0,0,0,0,0,0,0};  /* end sequence */
X    EXTERN char cerrbg[8] = {7,0,0,0,0,0,0,0}; /* string to print when errors start */
X    EXTERN char cerred[8] = {0,0,0,0,0,0,0,0};  /* when errors done */
X    EXTERN char ctopb[8] = {27,'L',0,0,0,0,0,0}; /* top blanks = reverse linefeed */
X    EXTERN char cinit[20] = {27,'&','j','@',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* start up sequence */
X    EXTERN char cendit[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
X    /* to end session */
X    EXTERN char cbotb[8] = {10,0,0,0,0,0,0,0};  /* bottom blank line sequence */
X    EXTERN char celin[8] = {27,'K',0,0,0,0,0,0};        /* erase to end of line */
X    EXTERN char cescr[8] = {27,'J',0,0,0,0,0,0};        /* erase to end of screen */
X    EXTERN char cclears[8]={27,'H',27,'J',0,0,0,0};    /* clear screen, home cusor */
X    EXTERN char cdelchr[8]={27,'P',0,0,0,0,0,0};    /* delete char on screen */
X    EXTERN char ccsrcm[8] = {27,'&','j','@',0,0,0,0};    /* set cursor to command mode */
X    EXTERN char ccsrin[8] = {27,'&','j','B',0,0,0,0};    /* set cursor to insert mode */
X    EXTERN char ciline[8] = {27,'L',0,0,0,0,0,0};        /* insert a line */
X    EXTERN char ckline[8] = {27,'M',0,0,0,0,0,0};        /* kill a line */
X    EXTERN char cundlb[8] = {0,'p',0,0,0,0,0,0};    /* turn on underline */
X    EXTERN char cundle[8] = {0,'q',0,0,0,0,0,0};    /* turn off underline */
X    EXTERN char cboldb[8] = {0,'p',0,0,0,0,0,0};    /* start bold */
X    EXTERN char cbolde[8] = {0,'q',0,0,0,0,0,0};    /* end bold */
X
X    EXTERN int dsp_mem = 1;
X    EXTERN int ddline = 12;
X    EXTERN int dscrl = 6;
X    EXTERN int dxcase = 0;
X#ifdef USECTRLZ
X    EXTERN int usecz = 1;
X#else
X    EXTERN int usecz = 0;
X#endif
X    EXTERN int autoin = 0;    /* TRUE if auto indent, FALSE otherwise */
X    EXTERN int logdef = 0;    /* backup log file by default 0->no, 1-> yes */
X    EXTERN char delkey = 8;
X    EXTERN int tvlins = 24;    /* number of lines on screen */
X    EXTERN int tvcols = 79;    /* number of columns on screen */
X    EXTERN int tvhardlines = 24;    /* real number of lines */
X    EXTERN int tvx = 0;        /* current x cursor position */
X    EXTERN int tvy = 0;        /* current y cursor position */
X    EXTERN int tvdlin = 0;     /* the "active" display line */
X    EXTERN int dsplin = 0;     /* the default display line */
X    EXTERN int tabspc = 8;     /* spacing for tabs */
X    EXTERN int leftmg = 0;    /* left margin of display */
X    EXTERN int wraplm = 0;    /* auto wrap? */
X    EXTERN int isibmpc = 0;    /* for possible use with a general version */
X#endif
X/* ********************************************************************** */
SHAR_EOF
echo ALL DONE!
exit 0